home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 January: Mac OS SDK / Dev.CD Jan 99 SDK1.toast / Development Kits / AppleScript / Development Tools / Sample Code / 7Edit 3.1 / Sources / SVEditUtils.c < prev    next >
Encoding:
Text File  |  1995-11-20  |  16.6 KB  |  626 lines  |  [TEXT/CWIE]
  1. // SVEditUtils.c
  2. //
  3. // 7Edit 3.1d1. Original version by Jon Lansdell and Nigel Humphreys.
  4. // 3.1 updates by Greg Sutton.
  5. // ©Apple Computer Inc 1995, all rights reserved.
  6.  
  7. /*
  8.     Changes for 3.1:
  9.     
  10.         12-Oct-95    : CW : Simplified FeatureIsImplemented routine.
  11.                            Added init of gHasDragManager flag in CheckEnvironment.
  12.  
  13. */
  14.  
  15.  
  16. #include <PLStringFuncs.h>
  17. #include <Events.h>
  18. #include <Traps.h>
  19. #include <Dialogs.h>
  20. #include <Fonts.h>
  21. #include <Packages.h>
  22. #include <ToolUtils.h>
  23. #include <AppleEvents.h>
  24. #include <CodeFragments.h>
  25. #include "SVEditUtils.h"
  26.  
  27. /**-----------------------------------------------------------------------
  28.         Name:             LesserOf
  29.         Purpose:        Returns the Lesser of two longints.
  30.     -----------------------------------------------------------------------**/
  31. #pragma segment Utils
  32.         
  33. pascal long LesserOf(long A, long B)
  34.  {
  35.    if (A<B)
  36.        return(A);
  37.      else
  38.        return(B);
  39.  }   /*LesserOf*/
  40.             
  41. /**-----------------------------------------------------------------------
  42.         Name:             GreaterOf
  43.         Purpose:        Returns the Greater of two longints.
  44.     -----------------------------------------------------------------------**/
  45.     
  46. #pragma segment Utils
  47.         
  48. pascal long GreaterOf(long A, long B)
  49.  {
  50.    if (A>B)
  51.        return(A);
  52.      else
  53.        return(B);
  54.  }  /*GreaterOf*/
  55.             
  56. /**-----------------------------------------------------------------------
  57.         Name:             ShowError
  58.         Purpose:        Reports an error to the user as both string and number.
  59.     -----------------------------------------------------------------------**/
  60. #pragma segment Utils
  61.         
  62. pascal void ShowError(Str255  theError,
  63.                                           long    theErrorCode)
  64. {
  65.    short     alertResult;
  66.    Str255    theString;
  67.      OSErr     myErr;
  68.      
  69.      myErr = AEInteractWithUser(kAEDefaultTimeout, nil,nil);
  70.      
  71.      if (myErr == noErr)
  72.        {
  73.              SetCursor(&qd.arrow);
  74.              NumToString(theErrorCode, theString);
  75.              ParamText(theError, theString, (unsigned char *)"", (unsigned char *)"");
  76.              alertResult = Alert(300, nil);
  77.          }
  78. } /* ShowError */
  79.  
  80. /**-----------------------------------------------------------------------
  81.         Name:             Ours
  82.         Purpose:        Checks the frontmost window belongs to the app.
  83.     -----------------------------------------------------------------------**/
  84. #pragma segment Utils        
  85.     
  86. pascal Boolean Ours(WindowPtr aWindow)
  87.  {
  88.         if (aWindow)
  89.             if (((WindowPeek)aWindow)->windowKind == zoomDocProc)
  90.                 return(true);
  91.         return(false);
  92. } /* Ours */
  93.  
  94. /**-----------------------------------------------------------------------
  95.         Name:             SetShortMenus
  96.         Purpose:        Cuts the menus down to a minimum - Apple File Edit.
  97.                                 Greys out the unavailable options - used when no docs open
  98.     -----------------------------------------------------------------------**/
  99. #pragma segment Utils        
  100.  
  101. pascal void SetShortMenus()
  102. { 
  103.     DeleteMenu(mfontID);
  104.     DeleteMenu(sizeID);
  105.     DeleteMenu(styleID);
  106.  
  107.     DisableItem(myMenus[fileM], fmClose);
  108.     DisableItem(myMenus[fileM], fmSave);
  109.     DisableItem(myMenus[fileM], fmSaveAs);
  110.     DisableItem(myMenus[fileM], fmRevert);
  111.     DisableItem(myMenus[fileM], fmPageSetUp);
  112.  
  113.     if (gGXIsPresent)
  114.     {
  115.         DisableItem(myMenus[fileM], fmPrint);
  116.         DisableItem(myMenus[fileM], fmPrintOne );
  117.     }
  118.     else
  119.         DisableItem(myMenus[fileM], fmNoGXPrint);
  120.  
  121.     /* now the unnecessary items on the edit menu */
  122.                 
  123.     DisableItem(myMenus[editM], undoCommand);
  124.     DisableItem(myMenus[editM], cutCommand);
  125.     DisableItem(myMenus[editM], copyCommand);
  126.     DisableItem(myMenus[editM], clearCommand);
  127.     DisableItem(myMenus[editM], pasteCommand);
  128.     DisableItem(myMenus[editM], selectAllCommand);
  129.  
  130.     DrawMenuBar();
  131. }  /* SetShortMenus */
  132.  
  133. /**-----------------------------------------------------------------------
  134.         Name:             SetLongMenus
  135.         Purpose:        Reinstates the full menu bar - called when first document
  136.                     opened.
  137.     -----------------------------------------------------------------------**/
  138. #pragma segment Utils        
  139.  
  140. pascal void SetLongMenus()
  141.   {
  142.         InsertMenu(myMenus[fontM], 0);
  143.         InsertMenu(myMenus[sizeM], 0);
  144.         InsertMenu(myMenus[styleM], 0);
  145.  
  146.         EnableItem(myMenus[fileM], fmClose);
  147.         EnableItem(myMenus[fileM], fmSave);
  148.         EnableItem(myMenus[fileM], fmSaveAs);
  149.         EnableItem(myMenus[fileM], fmRevert);
  150.         EnableItem(myMenus[fileM], fmPageSetUp);
  151.  
  152.         if (gGXIsPresent)
  153.         {
  154.             EnableItem(myMenus[fileM],  fmPrint );
  155.             EnableItem(myMenus[fileM],  fmPrintOne );
  156.         }
  157.         else
  158.             EnableItem(myMenus[fileM], fmNoGXPrint );
  159.  
  160.         /* now the necessary items on the edit menu -
  161.             many other items fixed on each pass thru the main event
  162.             loop or before the window pulled down
  163.         */
  164.         
  165.         EnableItem(myMenus[editM], selectAllCommand);
  166.  
  167.         DrawMenuBar();
  168.     }  /* SetLongMenus */
  169.  
  170. /**-----------------------------------------------------------------------
  171.         Name:             SetStyleMenu
  172.         Purpose:        Sets the style menu checking to reflect the style of the
  173.                     first character of the current selection in the given
  174.                                 document.
  175.     -----------------------------------------------------------------------**/
  176. #pragma segment Utils        
  177.         
  178. pascal void SetStyleMenu(DPtr theDoc)
  179.   {
  180.     TextStyle        theTStyle;
  181.         short       contMode;
  182.         short       i;
  183.         
  184.         contMode = doFace;
  185.         
  186.         TEContinuousStyle(&contMode,&theTStyle,theDoc->theText);
  187.         
  188.         if ((contMode & doFace) != 0)
  189.             {
  190.                 CheckItem(myMenus[styleM], cPlain,     (theTStyle.tsFace == 0));
  191.                 CheckItem(myMenus[styleM], cBold,      (bold      & theTStyle.tsFace));
  192.                 CheckItem(myMenus[styleM], cItalic,    (italic    & theTStyle.tsFace));
  193.                 CheckItem(myMenus[styleM], cUnderline, (underline & theTStyle.tsFace));
  194.                 CheckItem(myMenus[styleM], cOutline,   (outline   & theTStyle.tsFace));
  195.                 CheckItem(myMenus[styleM], cShadow,    (shadow    & theTStyle.tsFace));
  196.                 CheckItem(myMenus[styleM], cCondense,  (condense  & theTStyle.tsFace));
  197.                 CheckItem(myMenus[styleM], cExtend,    (extend    & theTStyle.tsFace));
  198.           }
  199.         else
  200.             for (i=cPlain; i<= cExtend; i++)
  201.                 CheckItem(myMenus[styleM], i,     false);
  202.   }
  203.  
  204. /**-----------------------------------------------------------------------
  205.     Name:       SetSizeMenu
  206.     Purpose:    Outline all the items if the current font is an
  207.                 outline font. Check the size of the current selection
  208.   -----------------------------------------------------------------------**/
  209. #pragma segment Utils        
  210.  
  211. pascal void SetSizeMenu(DPtr theDoc)
  212.   {
  213.       short             i;
  214.         short                aSize;
  215.         short                max;
  216.     long                 theSize;
  217.     Str255        name;
  218.     Boolean       sizeinMenu;
  219.     Boolean       oldState;
  220.     Point         numer;
  221.     TextStyle        theStyle;
  222.         TEHandle    myText;
  223.         short       contMode;
  224.       
  225.     numer.h = 1;
  226.     numer.v = 1;
  227.  
  228.     myText = theDoc->theText;
  229.         
  230.         contMode = doSize+doFont;
  231.         
  232.         TEContinuousStyle(&contMode,&theStyle,theDoc->theText);
  233.         
  234.     sizeinMenu = false;
  235.     max = CountMItems(myMenus[sizeM]);
  236.         for (i = 1; i <= max - 5; i++)
  237.       {
  238.                 GetItem(myMenus[sizeM], i, name);
  239.                 StringToNum(name, &theSize);
  240.                 aSize = (short)theSize;
  241.  
  242.                 if (RealFont(theStyle.tsFont, aSize) && (contMode & doFont) != 0) // there is only one font and this size exists
  243.                     SetItemStyle(myMenus[sizeM], i, outline);
  244.                 else
  245.                     SetItemStyle(myMenus[sizeM], i, 0);
  246.  
  247.                 if ((aSize == theStyle.tsSize) && (contMode & doSize) != 0)
  248.                     {
  249.                         sizeinMenu = true;
  250.                         CheckItem(myMenus[sizeM], i, true);
  251.                     }
  252.                 else
  253.                     CheckItem(myMenus[sizeM], i, false);
  254.             }
  255.         
  256.             /*
  257.                 if it's not a size in the menu,and there is only one size in the
  258.               selection range check the other item
  259.             */
  260.             
  261.             if (!sizeinMenu && (contMode & doSize) != 0)
  262.               CheckItem(myMenus[sizeM], max, true);
  263.             else
  264.                 CheckItem(myMenus[sizeM], max, false);
  265.  
  266.             /*if this is an outline font, set the rest of the items to outline style*/
  267.             /*RealFont will ensure that the sizes are outlined*/
  268.  
  269.             oldState = GetOutlinePreferred();
  270.             SetOutlinePreferred(true);
  271.             for (i = max-4; i <= max; i++)
  272.                 {
  273.                     if (IsOutline(numer, numer) && (contMode & doFont)!= 0)
  274.                         SetItemStyle(myMenus[sizeM], i, outline);
  275.                     else
  276.                         SetItemStyle(myMenus[sizeM], i, 0);
  277.                 }
  278.                 
  279.             SetOutlinePreferred(oldState);
  280.     }
  281.  
  282. /**-----------------------------------------------------------------------
  283.     Name:       SetFontMenu
  284.     Purpose:    Set the font menu according to the state of
  285.                                 current selection of the supplied document.
  286.   -----------------------------------------------------------------------**/
  287. #pragma segment Utils
  288.         
  289. pascal void SetFontMenu(DPtr theDoc)
  290.   {
  291.     MenuHandle        theMHandle;
  292.     short         theNumber;
  293.     short         i;
  294.     short                max;
  295.     Str255        name;
  296.     TextStyle     theStyle;
  297.         short         contMode;
  298.  
  299.         theMHandle = GetMHandle(mfontID);
  300.  
  301.         if (gFontMItem)
  302.       CheckItem(theMHandle, gFontMItem, false);
  303.             
  304.         max = CountMItems(theMHandle);
  305.  
  306.         contMode = doFont;
  307.         TEContinuousStyle(&contMode,&theStyle,theDoc->theText);
  308.  
  309.         gFontMItem = 0;
  310.         
  311.     if (contMode & doFont)
  312.             for (i=1; i<=max; i++)
  313.                 {
  314.                     GetItem(theMHandle, i, name);
  315.                     GetFNum(name, &theNumber);
  316.                     if (theNumber == theStyle.tsFont)
  317.                         gFontMItem = i;
  318.                 }
  319.  
  320.     if (gFontMItem)
  321.       CheckItem(theMHandle, gFontMItem, true);
  322.             
  323.         SetSizeMenu(theDoc);
  324.         SetStyleMenu(theDoc);
  325.     }
  326.  
  327. /**-----------------------------------------------------------------------
  328.     Name:       GetTempFileName
  329.     Purpose:    Fills newstring with a temporary file name.
  330.   -----------------------------------------------------------------------**/
  331.  
  332. #pragma segment Utils
  333.  
  334. pascal void GetTempFileName(DPtr aDoc,
  335.                             Str255 newString)
  336.  
  337.     {
  338.        Str255        s;
  339.      Str255        fileName;
  340.  
  341.         if (aDoc->everSaved == false)
  342.           PLstrcpy(fileName, (unsigned char *)"\pTEXTra");
  343.         else
  344.             PLstrcpy(fileName, aDoc->theFileName);
  345.  
  346.     /*generate a unique(ish) temporary filename*/
  347.         
  348.         if (fileName[0] > 21)
  349.           fileName[0] = 21;
  350.                 
  351.         NumToString(TickCount(), s);
  352.         
  353.         PLstrcat(fileName, s);
  354.         
  355.         PLstrcpy(newString,fileName);
  356.     }
  357.  
  358. /**-----------------------------------------------------------------------
  359.     Name:       SetText
  360.     Purpose:    Sets the text of the supplied itemNo in aDialog to 
  361.                                 theString and select it.
  362.   -----------------------------------------------------------------------**/
  363.  
  364. #pragma segment Utils
  365.  
  366. pascal void SetText(DialogPtr aDialog,
  367.                     short     itemNo,
  368.                     Str255    theString)
  369.   {
  370.     Handle      itemHandle;
  371.     Rect        box;
  372.     short       kind;
  373.     TEHandle    theTEHandle;
  374.  
  375.         GetDItem(aDialog, itemNo, &kind, &itemHandle, &box);
  376.         SetIText(itemHandle, theString);
  377.         
  378.         theTEHandle = ((DialogPeek)aDialog)->textH;
  379.  
  380.         /*set all the text to be selected*/
  381.         if (theTEHandle)
  382.             TESetSelect(0, 255, theTEHandle);
  383.     }
  384.             
  385. /**-----------------------------------------------------------------------
  386.     Name:       RetrieveText
  387.     Purpose:    Returns the text of anItem in aDialog in aString.
  388.   -----------------------------------------------------------------------**/
  389.  
  390. #pragma segment Utils
  391.  
  392. pascal void RetrieveText(DialogPtr aDialog,
  393.                                                short     anItem,
  394.                                                Str255    aString)
  395.   {
  396.      short      kind;
  397.      Rect       box;
  398.      Handle     itemHandle;
  399.  
  400.          GetDItem(aDialog, anItem, &kind, &itemHandle, &box);
  401.          GetIText(itemHandle, aString);
  402.   }
  403.  
  404. /**-----------------------------------------------------------------------
  405.     Name:       DrawDefaultOutline
  406.     Purpose:    Draws an outline around theItem.
  407.                                 Called as a useritem Proc by the dialog manager.
  408.                                 To use place a useritem over the default item in the
  409.                                 dialog and install the address of this proc as the item
  410.                                 handle.
  411.   -----------------------------------------------------------------------**/
  412.  
  413. #pragma segment Utils
  414.  
  415. pascal void DrawDefaultOutline(DialogPtr theDialog, short theItem)
  416.   {
  417.       short       kind;
  418.     Handle      itemHandle;
  419.     Rect        box;
  420.                 
  421.     GetDItem(theDialog, theItem, &kind, &itemHandle, &box);
  422.     PenSize(3, 3);
  423.     InsetRect(&box, - 4, - 4);
  424.     FrameRoundRect(&box, 16, 16);
  425.     PenNormal();
  426.         
  427.     }  /* DrawDefaultOutline */
  428.             
  429. /**-----------------------------------------------------------------------
  430.     Name:       AdornDefaultButton
  431.     Purpose:    Installs DrawDefaultOutline as the useritem proc
  432.                     for the given item.
  433.   -----------------------------------------------------------------------**/
  434.  
  435. #pragma segment Utils
  436.         
  437. pascal void AdornDefaultButton(DialogPtr theDialog,short theItem)
  438.   {
  439.       short       kind;
  440.     Handle      itemHandle;
  441.     Rect        box;
  442.  
  443.         GetDItem(theDialog, theItem, &kind, &itemHandle, &box);
  444.         SetDItem(theDialog, theItem, kind, (Handle)gDefaultButtonUPP, &box);
  445.   }
  446.  
  447.     /*-------  Determining of Gestalt is available ---------------*/
  448.     /*The following routines come from the Inside Mac VI recommendations*/
  449.     /*about how to find if a trap is available*/
  450.          /*
  451.             The glue for Gestalt will be in MPW 3.2, so if it is available we will also
  452.              need to check the system version
  453.         */
  454.  
  455. pascal void GetRectOfDialogItem(DialogPtr theDialog, short theItem, Rect *theRect)
  456.     {
  457.       short       kind;
  458.     Handle      itemHandle;
  459.         
  460.         GetDItem(theDialog, theItem, &kind, &itemHandle, theRect);
  461.     }
  462.  
  463. #pragma segment Utils
  464.  
  465. pascal short NumToolboxTraps(void)
  466.   {
  467.         if (NGetTrapAddress(_InitGraf, ToolTrap) == NGetTrapAddress(0xAA6E, ToolTrap))
  468.             return(0x200);
  469.         else
  470.             return(0x400);
  471.     }
  472.  
  473. #pragma segment Utils
  474.  
  475. #define TrapMask  0x0800
  476.  
  477. pascal TrapType GetTrapType(short theTrap)
  478.   {
  479.         if ((theTrap & TrapMask) > 0)
  480.             return(ToolTrap);
  481.         else
  482.             return(OSTrap);
  483.     }
  484.  
  485. #pragma segment Utils
  486.  
  487. pascal Boolean TrapAvailable(short theTrap)
  488.   {
  489.         TrapType  tType;
  490.  
  491.         tType = GetTrapType(theTrap);
  492.         if (tType == ToolTrap)
  493.             {
  494.                 theTrap = theTrap & 0x07FF;
  495.                 if (theTrap >= NumToolboxTraps())
  496.                     theTrap = _Unimplemented;
  497.             }
  498.         return(NGetTrapAddress(theTrap, tType) != NGetTrapAddress(_Unimplemented,ToolTrap));
  499.     }
  500.  
  501. #pragma segment Utils
  502.  
  503. #define _Gestalt 0xA1AD
  504.  
  505. pascal Boolean GestaltAvailable()
  506.   {
  507.         return(TrapAvailable(_Gestalt));
  508.     }
  509.  
  510. /**------  FeatureIsImplemented    ------------**/
  511. /*This is called to use Gestalt to determine if a feature is implemented.
  512.  This applies to only those referenced by OSType*/
  513.  
  514. #pragma segment Utils
  515.  
  516.  
  517. pascal Boolean FeatureIsImplemented ( OSType theFeature, short theTestBit )
  518. {
  519.     OSErr     err;
  520.     long      result;
  521.  
  522.     err = Gestalt ( theFeature, &result );
  523.     return (err == noErr && (result & (1L << theTestBit)));
  524.     
  525. }
  526.  
  527.  
  528.  
  529.  
  530. #pragma segment Utils
  531.  
  532. pascal Boolean CheckEnvironment()
  533.   {
  534.         /*
  535.          first determine of Gestalt is available- if it isn't exit
  536.          as we only run under 7.0.  It could it present in 6.04 - so we need
  537.          to do some further checks for important features
  538.         */
  539.  
  540.         gGestaltAvailable = GestaltAvailable();
  541.         
  542.         if (!gGestaltAvailable)
  543.             return(false);
  544.  
  545.     /*first check if the Edition Manager is present*/
  546.                 
  547.     gEditionManagerImplemented = FeatureIsImplemented(gestaltEditionMgrAttr,
  548.                                                                                                           gestaltEditionMgrPresent);
  549.  
  550.         /*and for good measure- the Alias manager*/
  551.                 
  552.         gAliasManagerImplemented  = FeatureIsImplemented(gestaltAliasMgrAttr,
  553.                                                                                                          gestaltAliasMgrPresent);
  554.             
  555.         /*check for the AppleEvents manager - we certainly can't work without it*/
  556.         
  557.         gAppleEventsImplemented   = FeatureIsImplemented(gestaltAppleEventsAttr,
  558.                                                                                                          gestaltAppleEventsPresent);
  559.         
  560.         /*check if recording is implemented*/
  561.         
  562.         gRecordingImplemented   = FeatureIsImplemented(gestaltAppleEventsAttr,1);
  563.             
  564.         /*check for the Outline fonts*/
  565.         
  566.         gOutlineFontsImplemented  = FeatureIsImplemented(gestaltFontMgrAttr,
  567.                                                                                                          gestaltOutlineFonts);
  568.         
  569.     
  570.     // We would also like the Drag Manager
  571.     gHasDragManager = FeatureIsImplemented ( gestaltDragMgrAttr, gestaltDragMgrPresent );
  572.     
  573.     // It isn't enough to use Gestalt because we may not have sucessfully linked
  574.     // to the DragLib shared library. So, we also need to test one of the symbols
  575.     // against kUnresolvedSymbol to make sure we have a valid connection to it.
  576.     
  577. #if GENERATINGCFM
  578.     if ( gHasDragManager )
  579.         gHasDragManager = (InstallTrackingHandler != (void*) kUnresolvedSymbolAddress);
  580. #endif
  581.  
  582.  
  583.         return (gEditionManagerImplemented &&
  584.                         gAliasManagerImplemented   &&
  585.                         gAppleEventsImplemented    &&
  586.                         gOutlineFontsImplemented);
  587.                                 
  588.     }  /* CheckEnvironment */
  589.             
  590.     /*
  591.         DoPageSetup returns true if the page setup of the document is altered
  592.     */
  593.     
  594.     pascal Boolean DoPageSetup(DPtr theDoc)
  595.         {
  596.             Boolean result = false;
  597.                 
  598.                 if (!gGXIsPresent)
  599.                     if (theDoc)
  600.                         {
  601.                             PrOpen();
  602.                             result =  PrStlDialog(theDoc->thePrintSetup);
  603.                             PrClose();
  604.                         }
  605.                     
  606.                 return(result);
  607.         }  /* DoPageSetup */
  608.  
  609. /*
  610.     Name:    CtrlKeyPressed
  611.     Purpose: Returns true if control key pressed during event
  612. */
  613. pascal Boolean CtrlKeyPressed(const EventRecord *theEvent)
  614.     {
  615.         return((theEvent->modifiers & controlKey) != 0);
  616.     }
  617.     
  618. /*
  619.     Name:    OptionKeyPressed
  620.     Purpose: Returns true if option key pressed during event
  621. */
  622. pascal Boolean OptionKeyPressed(const EventRecord *theEvent)
  623.     {
  624.         return((theEvent->modifiers & optionKey) != 0);
  625.     }
  626.